import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[][] array1 = new int[2][];//Java当中 不可以省略行 但是可以省略列
        array1[0] = new int[3];
        array1[1] = new int[5];

        System.out.println(array1[0].length);//打印结果是3
        System.out.println(array1[1].length);//打印结果是5
        //说明Java中数组每行的列数可以是不同的

        for(int i = 0; i < array1.length; i++) {
            for(int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void main7(String[] args) {
        int[][] array1 = {{1,2,3},{4,5,6}};
        System.out.println(array1.length);//打印结果是2    行的长度
        System.out.println(array1[0].length);//打印结果是3   列的长度
        for(int i = 0; i < 2; i++) {
            for(int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("======================");
       for(int[] tmp:array1) {
           for(int x:tmp) {
               System.out.print(x+" ");
           }
           System.out.println();
       }
        System.out.println("===============");
       String ret = Arrays.deepToString(array1);//类似与一维数组的打印，也是没有下标的，只是将它组合好了
        System.out.println(ret);

    }
    //二维数组的创建
    public static void main6(String[] args) {
        //二维数组的创建方式
        int[][] array1 = {{1,2,3},{4,5,6}};//必须要用{}大括号隔开
        int[][] array2 = new int[2][3];
        int[][] array3 = new int[][]{{1,2,3},{4,5,6}};

        for(int i = 0; i < 2; i++) {
            for(int j = 0; j < 3; j++) {
                System.out.print(array1[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void main5(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = new int[array.length];
        System.arraycopy(array,0,copy,0,array.length);//System.arraycopy(原数组名，原数组拷贝的起始位置，目的地数组，拷贝目的地数组的范围，拷贝的长度）
        //Arrays.copyOfRange(array,1,4);//copyOfRange（数组名,1，4）1，4表示拷贝的一个范围，拷贝的是下标1-4的[1,4)
        /*int[] ret = copy(array);
        System.out.println(Arrays.toString(array));
        System.out.println("==================");

        int[] ret = Arrays.copyOf(array,array.length*2);//这里的*2是对数组的扩容
        //copyOf(数组名，新数组的长度 )
        System.out.println(Arrays.toString(ret));*/
    }
    public static int[] copy(int[] array) {
        int[] copyArray = new int[array.length];
        for(int i = 0; i < array.length; i++) {
            copyArray[i] = array[i];
        }
        return copyArray;
    }
    //数组的排序
    public static void bubbleSort(int[] array1) {
        // i 控制趟数（数组元素个数-1）
        for(int i = 0; i < array1.length-1; i++) {
            // j 控制每一趟的次数,每完成一趟，一趟中的比较次数就会减少一次

            //优化：可能这个数组当中只有部分元素的顺序不是升序的，我们就不需要进行多趟的排序
            boolean flg = true;
            for(int j = 0; j < array1.length-1-i; j++) {
                if(array1[j] > array1[j+1]) {//这个是按照升序顺序排的
                    int tmp = array1[j];
                    array1[j] = array1[j+1];
                    array1[j+1] = tmp;
                    flg = false;
                }
            }
            //进行判断是否进行了排序，没有进行排序的话  flg  就不会被修改（也就说明这个数组本身就是有序的）
            if(flg == true)
            {
                break;//有序就就直接跳出循环
            }
        }
    }
    public static void main4(String[] args) {
        int a = 10;
        int[] array = new int[a];//java支持变常数组

        int[] array1 = {1,8,5,6,97,12,16};

        /*System.out.println("排序前的数组： " + Arrays.toString(array1));
        Arrays.sort(array1);//Java提供的排序
        System.out.println("排序后的数组： "+ Arrays.toString(array1));
        int index = Arrays.binarySearch(array1,6);//Java提供的查找方法
        System.out.println(index);  //都是在有序的数组查找的
        */
        bubbleSort(array1);
        System.out.println(Arrays.toString(array1));

    }
    //二分查找(使用条件：必须是有序数组)
    public static int binarySearch(int[] array,int key) {
        //防止传的是null
        if(array == null)
            return -2;//数组为空时返回null
        int left = 0;
        int right = array.length - 1;
        while(left <= right) {
            //当左下标和右下标不相等时就说明在该数组找不到key
            int m = (left + right) / 2;
            if(array[m] < key) {
                //说明这个数下标为m的右边
                left = m + 1;
            }
            else if(array[m] > key) {
                //说明这个数在m的左边
                right = m - 1;
            }
            else
                return m;//找到则返回key对应的下标
        }
        return -1;//没有找到则返回-1
    }
    public static int findVal(int[] array, int key) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;//数组里面的每个元素都进行比较时没有出现和key想等的则就返回-1，表示没有找到
    }

    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5,9,10,22,35,27};
        int key = 10;//返回的是对应数字的下标
        System.out.println("二分查找函数 " + binarySearch(array, key));;
        System.out.println("顺序查找 " + findVal(array, key));
    }
    //当我们需要函数返回多个值时，我们可以使用数组来返回
    /*public static void main2(String[] args) {
        //引用变量 引用 在这个变量当中储存的是地址
        int[] array = {1,2,3,4,5};
//        System.out.println(array[10]);//运行之后会报错，数组越界

        *//*int[] array2 = null;
        System.out.println(array2.length);//也会报错，空指针异常*//*
        int[] array2 = array;
        array2[0] = 8;
        String ret1 = Arrays.toString(array);//toString的返回值是字符串
        String ret2 = Arrays.toString(array2);
        System.out.println(ret1);//输出结果是8 2 3 4 5
        System.out.println(ret2);//输出结果是8 2 3 4 5
        //因为array和array里面存储的是同一个地址
    }
*/
    //写一个返回字符串的方法
    public static void main1(String[] args) {
        int[] array = {1,2,3,4,5,6};
        String ret = myToString(array);
        System.out.println(ret);
    }
    public static String myToString(int[] array) {
        //这个方法的缺点，当数组为空的时候就会出现报错
        //所以我们要进行一个判断，要是我们数组为null（空）时，我们应该输出一个null
        if(array == null)
        {
            return "null";
        }
        //先打印[ 在打印数组里面的元素，并且在每打印一个元素之后就打印一个（逗号）但是最后一个元素不需要打印（逗号）打印]
        String str = "[";
        for(int i = 0; i < array.length; i++) {
            str += array[i];
            if(i != array.length-1) {
                str += ",";
            }
        }
        str += "]";
        return str;
    }
}
